import os
import math
import shutil
import time

import numpy as np  # 新增：颜色填充需要的数值计算库
from datetime import datetime

import openpyxl
from openpyxl import load_workbook, Workbook
from openpyxl.styles import PatternFill  # 新增：单元格填充样式
from openpyxl.utils import get_column_letter  # 新增：列字母与数字转换
from copy import copy
import win32com.client as win32
from PIL import ImageGrab
import pythoncom

from datetime import datetime
import openpyxl
from openpyxl.styles import PatternFill
from openpyxl.utils import get_column_letter
import numpy as np


def capture_excel_sheets_screenshots(excel_path, output_dir="../spiltExcel/output/images", start_from=2,header_rows=3):
    """
    截取Excel文件中工作表的截图，从指定工作表开始

    参数:
        excel_path: Excel文件路径
        output_dir: 截图保存目录
        start_from: 开始截图的工作表索引（从1开始计数）
    """
    # 获取当前日期
    dateStamp = datetime.now().strftime("%Y%m%d")
    output_dir =output_dir
    # 创建输出目录
    os.makedirs(output_dir, exist_ok=True)

    pythoncom.CoInitialize()  # 初始化COM环境

    try:
        # 启动Excel应用程序
        excel = win32.gencache.EnsureDispatch('Excel.Application')
        excel.Visible = False  # 后台运行，不显示界面
        excel.DisplayAlerts = False  # 禁用警告对话框

        # 打开工作簿
        workbook = excel.Workbooks.Open(os.path.abspath(excel_path))

        # 提取Excel文件名（不含扩展名）
        excel_filename = os.path.splitext(os.path.basename(excel_path))[0]

        # 获取工作表数量
        sheet_count = workbook.Sheets.Count

        if sheet_count < start_from:
            print(f"警告: 工作表数量({sheet_count})小于起始索引({start_from})，无法截图")
            return

        # 遍历工作表并截图
        for sheet_idx in range(start_from, sheet_count + 1):
            sheet = workbook.Sheets(sheet_idx)

            # 获取工作表名称
            sheet_name = sheet.Name
            print(f"正在截取工作表: {sheet_name}")

            # 选择整个工作表数据区域
            header_rows = 3  # 假设表头为前3行
            last_col = 1
            # 查找表头区域的有效最后一列
            for row in range(1, header_rows + 1):
                for col in range(1, sheet.UsedRange.Columns.Count + 1):
                    if sheet.Cells(row, col).Value is not None:
                        last_col = max(last_col, col)

            # 获取数据总行数（排除空行）
            last_row = sheet.UsedRange.Rows.Count

            # 创建固定范围（A列到有效最后一列）
            fixed_range = sheet.Range(
                sheet.Cells(1, 1),  # A1
                sheet.Cells(last_row, last_col)  # 有效最后一列
            )

            fixed_range.CopyPicture(
                Appearance=win32.constants.xlScreen,
                Format=win32.constants.xlBitmap
            )
            # 延迟和重试机制获取剪贴板图片
            import time
            max_retries = 3
            retry_delay = 0.5
            img = None

            for attempt in range(max_retries):
                time.sleep(retry_delay)
                img = ImageGrab.grabclipboard()
                if img:
                    break
                print(f"重试获取 {sheet_name} 截图 (尝试 {attempt + 1}/{max_retries})")

            # 将剪贴板中的图片保存到文件（添加Excel文件名前缀）
            if img:
                # 文件名格式: [Excel文件名]_[工作表名].png
                img_path = os.path.join(output_dir, f"{sheet_name}.png")
                img.save(img_path)
                print(f"截图已保存: {img_path}")
            else:
                print(f"警告: 无法获取工作表 {sheet_name} 的截图")

    except Exception as e:
        print(f"截图过程中发生错误: {str(e)}")
    finally:
        # 清理资源
        try:
            workbook.Close(SaveChanges=False)
        except:
            pass
        excel.Quit()
        pythoncom.CoUninitialize()  # 释放COM环境

# 添加行填充颜色函数
def apply_row_based_gradient(input_file, output_file=None, columns=None, header_rows=3):
    """
    根据行数据应用基于值的渐变颜色

    参数:
        input_file: 输入Excel文件路径
        output_file: 输出Excel文件路径，默认为带时间戳的文件名
        columns: 要处理的列，可以是列号列表[1,2,3]或列字母列表['A','B','C']
        header_rows: 表头行数，默认3行
    """
    try:
        # 1. 加载Excel文件
        wb = openpyxl.load_workbook(input_file)
        ws = wb.active

        # 2. 定义精确的颜色映射规则
        color_rules = {
            (-100, 0): {
                'start': "FF0000FF",  # 深蓝
                'end': "FFADD8E6"  # 浅蓝
            },
            (0, 50): {
                'start': "FFD3D3D3",  # 浅灰
                'end': "FFFFC0CB"  # 深粉
            },
            (50, 100): {
                'start': "FFFFC0CB",  # 深粉 (保持连续性)
                'end': "FFFF4500"  # 橙红 (浅红)
            },
            (100, float('inf')): "FFFF0000"  # 红色
        }
        default_color = "FFCCCCCC"  # 默认灰色


        # 3. 颜色插值函数
        def interpolate_color(value, min_val, max_val, start_color, end_color):
            """根据数值在区间内的位置计算渐变颜色"""

            # 拆分ARGB颜色值
            def split_color(color):
                return (
                    int(color[2:4], 16),  # R
                    int(color[4:6], 16),  # G
                    int(color[6:8], 16)  # B
                )

            # 计算插值比例
            factor = (value - min_val) / (max_val - min_val)
            start_rgb = split_color(start_color)
            end_rgb = split_color(end_color)

            # 生成插值颜色
            new_rgb = [
                int(start_rgb[i] + (end_rgb[i] - start_rgb[i]) * factor)
                for i in range(3)
            ]

            # 返回ARGB格式
            return f"FF{new_rgb[0]:02X}{new_rgb[1]:02X}{new_rgb[2]:02X}"

        # 4. 处理列参数 (修复缩进 - 将此部分移出interpolate_color函数)
        data_cols = ws.max_column
        columns_to_process = []
        if columns:
            for col in columns:
                try:
                    # 统一转换为列数字
                    if isinstance(col, str) and col.isalpha():
                        col_num = openpyxl.utils.column_index_from_string(col.upper())
                    elif isinstance(col, int):
                        col_num = col
                    else:
                        print(f"警告: 忽略无效的列标识 '{col}'")
                        continue

                    # 验证列号有效性
                    if 1 <= col_num <= ws.max_column:
                        columns_to_process.append(col_num)
                    else:
                        print(f"警告: 列号 {col_num} 超出有效范围(1-{ws.max_column})")
                except Exception as e:
                    print(f"解析列标识 '{col}' 时发生错误: {str(e)}")
        else:
            # 默认处理所有数据列
            columns_to_process = list(range(1, ws.max_column + 1))

        # 去重并排序
        columns_to_process = sorted(list(set(columns_to_process)))
        print(f"工作表最大列数: {ws.max_column}")
        print(f"实际处理列号: {columns_to_process}")
        print(f"列字母标识: {[get_column_letter(c) for c in columns_to_process]}")

        # 5. 遍历单元格应用颜色（添加列存在性验证）
        for col_num in columns_to_process:
            if col_num > ws.max_column:
                print(f"跳过不存在的列号: {col_num}")
                continue

            col_letter = get_column_letter(col_num)
            print(f"正在处理列: {col_letter}({col_num})")

            for row in range(header_rows + 1, ws.max_row + 1):  # 跳过表头
                cell = ws[f"{col_letter}{row}"]
                value = cell.value

                # 跳过非数值单元格
                if not isinstance(value, (int, float)):
                    continue

                # 匹配颜色规则
                fill_color = default_color
                for range_, colors in color_rules.items():
                    if range_[0] <= value < range_[1]:
                        if isinstance(colors, dict):  # 渐变区间
                            fill_color = interpolate_color(
                                value,
                                range_[0],
                                range_[1],
                                colors['start'],
                                colors['end']
                            )
                        else:  # 固定颜色区间
                            fill_color = colors
                        break

                # 应用颜色填充
                cell.fill = PatternFill(
                    start_color=fill_color,
                    end_color=fill_color,
                    fill_type="solid"
                )

        # 6. 保存结果
        if not output_file:
            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
            output_file = f"colorExcel/行填充颜色报表_{timestamp}.xlsx"

        wb.save(output_file)
        print(f"行填充报表生成成功！文件保存为：{output_file}")
        return output_file

    except Exception as e:
        print(f"行填充执行出错: {e}")
        return None


def apply_column_based_colors(input_file=None, output_file=None, columns=None, header_rows=1):
    """
     按列填充Excel单元格颜色，根据每列数值的大小应用不同颜色

     参数:
         input_file: 输入Excel文件路径，默认为'colorExcel/原始文件1546.xlsx'
         output_file: 输出Excel文件路径，默认为带时间戳的文件名
         columns: 要处理的列，可以是列号列表[1,2,3]或列字母列表['A','B','C']，默认处理所有列
         header_rows: 表头行数，默认1
     """
    try:
        # 1. 设置默认文件路径
        if not input_file:
            input_file = '../colorExcel/原始文件1546.xlsx'

        if not output_file:
            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
            output_file = f"colorExcel/按列填充颜色报表_{timestamp}.xlsx"

        # 2. 加载Excel文件
        print(f"正在加载Excel文件: {input_file}")
        wb = openpyxl.load_workbook(input_file)
        ws = wb.active

        # 3. 定义颜色
        colors = {
            0: "FFFFFFFF",  # 白色
            1: "FFFFE6E6",  # 淡粉色
            2: "FFFFCCCC",  # 浅粉色
            3: "FFFFB3B3",  # 粉色
            4: "FFFF9999",  # 深粉色
            5: "FFFF8080"  # 淡红色
        }

        # 4. 处理列参数
        data_rows = ws.max_row - header_rows  # 减去表头行
        data_cols = ws.max_column

        # 确定要处理的列
        columns_to_process = []
        if columns:
            for col in columns:
                if isinstance(col, str) and col.isalpha():
                    # 列字母转数字 (A->1, B->2...)
                    col_num = openpyxl.utils.column_index_from_string(col.upper())
                    columns_to_process.append(col_num)
                elif isinstance(col, int) and col > 0:
                    columns_to_process.append(col)
                else:
                    print(f"警告: 忽略无效的列标识 '{col}'")
        else:
            # 默认处理所有列
            columns_to_process = list(range(1, data_cols + 1))

        # 去重并排序
        columns_to_process = sorted(list(set(columns_to_process)))
        print(f"将处理以下列: {[get_column_letter(c) for c in columns_to_process]}")

        # 5. 按列处理并填充颜色
        for col_num in columns_to_process:
            col_letter = get_column_letter(col_num)
            print(f"正在处理列: {col_letter}")

            # 获取列数据（跳过表头行）
            column_data = []
            # 修改：从header_rows + 1行开始处理数据
            for row in range(header_rows + 1, ws.max_row + 1):
                cell = ws.cell(row=row, column=col_num)
                try:
                    # 尝试转换为数值
                    value = float(cell.value) if cell.value else 0
                    column_data.append(value)
                except (ValueError, TypeError):
                    # 非数值类型不参与颜色映射
                    column_data.append(0)

            if not column_data:
                print(f"警告: 列 {col_letter} 没有可处理的数据")
                continue

            # 计算分位数（使用numpy）
            # 修改后的分位数计算逻辑
            try:
                max_val = max(column_data)
                min_val = min(column_data)
                if max_val == min_val:
                    # 所有值相同时的处理
                    percentiles = [min_val] * 6
                else:
                    # 计算基于最大最小值的等距分位点
                    range_val = max_val - min_val
                    step = range_val / 5
                    percentiles = [min_val + i * step for i in range(6)]
            except Exception as e:
                print(f"计算分位数失败: {e}，使用默认分箱")
                # 使用linspace生成更可靠的分位点
                percentiles = np.linspace(min(column_data), max(column_data), 6)

            # 6. 为单元格填充颜色
            for row_idx, row in enumerate(range(header_rows + 1, ws.max_row + 1)):
                cell = ws.cell(row=row, column=col_num)
                # 修改：索引计算应考虑表头行数
                value = column_data[row_idx] if row_idx < len(column_data) else None

                # 确定颜色等级
                color_level = 0
                for i in range(1, len(percentiles)):
                    if value > percentiles[i]:
                        color_level = i

                # 确保颜色等级在有效范围内
                color_level = max(0, min(color_level, len(colors) - 1))

                # 应用填充颜色
                fill = PatternFill(start_color=colors[color_level],
                                   end_color=colors[color_level],
                                   fill_type="solid")
                cell.fill = fill

        # 7. 保存文件
        print(f"正在保存颜色填充后的文件: {output_file}")
        wb.save(output_file)
        print(f"颜色填充完成，文件已保存至: {output_file}")
        return output_file

    except Exception as e:
        print(f"颜色填充处理失败: {str(e)}")
        return None


def copy_worksheet(source_sheet, target_sheet, fixed_row_height=None):
    """复制整个工作表，强制应用统一行高（含表头）"""
    # 精确复制列宽
    for col_letter, col_dim in source_sheet.column_dimensions.items():
        if col_dim.width is not None:
            target_sheet.column_dimensions[col_letter].width = col_dim.width

    # 应用统一行高
    for row_idx in range(1, source_sheet.max_row + 1):
        if fixed_row_height is not None:
            target_sheet.row_dimensions[row_idx].height = fixed_row_height
        elif source_sheet.row_dimensions[row_idx].height is not None:
            target_sheet.row_dimensions[row_idx].height = source_sheet.row_dimensions[row_idx].height

    # 复制单元格值和样式
    for row in source_sheet.iter_rows():
        for cell in row:
            new_cell = target_sheet.cell(row=cell.row, column=cell.column, value=cell.value)
            if cell.has_style:
                new_cell.font = copy(cell.font)
                new_cell.border = copy(cell.border)
                new_cell.fill = copy(cell.fill)
                new_cell.number_format = cell.number_format
                new_cell.alignment = copy(cell.alignment)

    # 复制合并单元格
    for merged_range in source_sheet.merged_cells.ranges:
        if hasattr(merged_range, 'coord'):
            target_sheet.merge_cells(merged_range.coord)
        else:
            target_sheet.merge_cells(
                start_row=merged_range.min_row,
                end_row=merged_range.max_row,
                start_column=merged_range.min_col,
                end_column=merged_range.max_col
            )

def split_excel_with_format(input_path, output_path, chunk_size=30, header_rows=3, fixed_row_height=None,
                            color_mode=None, color_columns=None, row_color_columns=None):
    """拆分Excel文件，支持自定义行高和分块大小，并可选择性地为指定列或行填充颜色

    参数:
        input_path: 输入Excel文件路径
        output_path: 输出Excel文件路径
        chunk_size: 每个Sheet的数据行数，默认30行
        header_rows: 表头行数，默认3行
        fixed_row_height: 统一行高，默认为None（保留原始行高）
        color_mode: 颜色填充模式，可选值: 'row' (行填充), 'column' (列填充), None (不填充)
        color_columns: 列填充时要填充颜色的列，可以是列号列表[1,2,3]或列字母列表['A','B','C']
        row_color_columns: 行填充时要填充颜色的列，可以是列号列表[1,2,3]或列字母列表['A','B','C']
    """
    # 先进行颜色填充（如果指定了color_mode）
    temp_colored_file = None
    if color_mode in ['row', 'column']:
        print(f"正在以{color_mode}模式为指定区域填充颜色...")
        # 创建临时文件路径用于颜色填充
        temp_colored_file = os.path.splitext(output_path)[0] + "_colored_temp.xlsx"

        temp_colored_file = None
        if color_mode in ['row', 'column']:
            # 检查对应模式的列参数
            if (color_mode == 'column' and not color_columns) or (color_mode == 'row' and not row_color_columns):
                print(f"⚠️ 未指定{color_mode}填充列，跳过颜色填充")
                color_mode = None
            else:
                print(f"正在以{color_mode}模式为指定区域填充颜色...")
                temp_colored_file = os.path.splitext(output_path)[0] + "_colored_temp.xlsx"

                if color_mode == 'column':
                    colored_file = apply_column_based_colors(
                        input_file=input_path,
                        output_file=temp_colored_file,
                        columns=color_columns,
                        header_rows=header_rows
                    )
                elif color_mode == 'row':
                    colored_file = apply_row_based_gradient(
                        input_file=input_path,
                        output_file=temp_colored_file,
                        columns=row_color_columns,
                        header_rows=header_rows
                    )

                if not colored_file:
                    print(f"{color_mode}填充失败，将使用原始文件继续进行拆分")
                    input_path = input_path
                else:
                    input_path = colored_file


    # 加载原始工作簿（可能是颜色填充后的文件）
    book = load_workbook(input_path)
    sheet = book.active

    # 创建新工作簿
    output_book = Workbook()
    output_book.remove(output_book.active)

    # 全量数据Sheet（应用统一行高）
    full_sheet = output_book.create_sheet("全量数据")
    copy_worksheet(sheet, full_sheet, fixed_row_height)

    # 记录原始列宽
    global_col_widths = {}
    for col_letter, col_dim in sheet.column_dimensions.items():
        if col_dim.width is not None:
            global_col_widths[col_letter] = col_dim.width

    # 获取合并单元格信息
    merged_ranges = list(sheet.merged_cells.ranges)

    # 计算分块
    total_data_rows = 0
    for row in range(header_rows + 1, sheet.max_row + 1):
        # 检查整行是否为空
        # 检查第一列是否为数值类型
        if sheet[row][0].value is None:  # 修改为仅检查第一列
            break
        total_data_rows += 1

    print("总行数为:", total_data_rows)
    chunks = range(0, total_data_rows, chunk_size)

    for i, start_idx in enumerate(chunks):
        if start_idx >= total_data_rows:
            break
        end_idx = min(start_idx + chunk_size - 1, total_data_rows - 1)
        sheet_name = f"{start_idx + 1}-{end_idx + 1}行"
        new_sheet = output_book.create_sheet(sheet_name)

        # 应用全局列宽
        for col_letter, width in global_col_widths.items():
            new_sheet.column_dimensions[col_letter].width = width

        # 表头行强制应用统一行高
        for row_idx in range(1, header_rows + 1):
            if fixed_row_height is not None:
                new_sheet.row_dimensions[row_idx].height = fixed_row_height

            # 复制单元格
            for col_idx, cell in enumerate(sheet[row_idx], 1):
                new_cell = new_sheet.cell(row=row_idx, column=col_idx, value=cell.value)
                if cell.has_style:
                    new_cell.font = copy(cell.font)
                    new_cell.border = copy(cell.border)
                    new_cell.fill = copy(cell.fill)
                    new_cell.number_format = cell.number_format
                    new_cell.alignment = copy(cell.alignment)

        # 复制表头合并单元格
        for merged_range in merged_ranges:
            if merged_range.min_row <= header_rows and merged_range.max_row <= header_rows:
                new_sheet.merge_cells(
                    start_row=merged_range.min_row,
                    end_row=merged_range.max_row,
                    start_column=merged_range.min_col,
                    end_column=merged_range.max_col
                )

        # 复制数据行（应用统一行高）
        data_start_row = header_rows + start_idx + 1
        data_end_row = min(header_rows + end_idx + 1, sheet.max_row)

        for src_row_idx in range(data_start_row, data_end_row + 1):
            dest_row_idx = src_row_idx - start_idx  # 目标行号计算
            if fixed_row_height is not None:
                new_sheet.row_dimensions[dest_row_idx].height = fixed_row_height

            for col_idx, cell in enumerate(sheet[src_row_idx], 1):
                new_cell = new_sheet.cell(row=dest_row_idx, column=col_idx, value=cell.value)
                if cell.has_style:
                    new_cell.font = copy(cell.font)
                    new_cell.border = copy(cell.border)
                    new_cell.fill = copy(cell.fill)
                    new_cell.number_format = cell.number_format
                    new_cell.alignment = copy(cell.alignment)

    output_book.save(output_path)

    # 删除临时文件
    if temp_colored_file and os.path.exists(temp_colored_file):
        try:
            os.remove(temp_colored_file)
            print(f"临时颜色文件已删除: {temp_colored_file}")
        except Exception as e:
            print(f"警告: 无法删除临时文件 {temp_colored_file}: {e}")

    return output_path

def split_excel_inputFile(input_file,output_dir,mode,header_rows=3):
    """
    主函数，根据用户输入的模式和参数调用split_excel.py的split_excel_file函数
    """

    import win32com
    delFile=win32com.__gen_path__
    # 获取delFile目录下的文件夹
    folders = [f for f in os.listdir(delFile) if os.path.isdir(os.path.join(delFile, f))]
    for folder in folders:
        folder_path = os.path.join(delFile, folder)
        print(f"删除临时文件夹: {folder_path}")
        shutil.rmtree(folder_path)
        time.sleep(2)

    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
    # 输出目录
    os.makedirs(f'{output_dir}/excel', exist_ok=True)
    output_file = f"{output_dir}/excel/分割结果_{timestamp}.xlsx"
    try:
        if mode not in ['1', '2', '3']:
            print("⚠️ 无效选择，已使用默认配置")
            mode = '1'

        if mode == '1':
            # 使用默认配置
            fixed_height = 90
            chunk_size = 15
            color_mode = 'column'
            color_columns = ['D', 'E']
            row_color_columns = None
            print("\n✅ 使用默认配置：")
            print(f"  - 行高: {fixed_height}磅")
            print(f"  - 分块大小: {chunk_size}行/Sheet")
            print(f"  - 列填充: {', '.join(color_columns)}")
        elif mode == '2':
            # 获取用户输入的统一行高
            user_input_height = input("请输入统一的固定行高值（磅），直接回车则保留原始行高: ")
            fixed_height = float(user_input_height) if user_input_height.strip() else None

            # 获取用户输入的分块大小
            user_input_chunk = input("请输入每个Sheet的数据行数（默认30行）: ")
            try:
                chunk_size = int(user_input_chunk) if user_input_chunk.strip() else 30
                if chunk_size <= 0:
                    print("⚠️ 行数必须大于0，已使用默认值30")
                    chunk_size = 30
            except ValueError:
                print("⚠️ 输入无效，已使用默认分块大小30行")
                chunk_size = 30

            # 获取用户选择的颜色填充模式
            color_mode = None
            color_columns = None
            row_color_columns = None  # 新增：行填充列参数
            while True:
                color_mode_input = input(
                    "请选择颜色填充模式 (row-行填充, column-列填充, 直接回车-不填充): ").strip().lower()
                if not color_mode_input:
                    color_mode = None
                    break
                elif color_mode_input in ['row', 'column']:
                    color_mode = color_mode_input

                    # 根据填充模式获取列
                    if color_mode == 'column':
                        user_input_color = input("请输入要填充颜色的列（例如: B,C,D）: ")
                        color_columns = []
                        if user_input_color.strip():
                            for col in user_input_color.split(','):
                                col = col.strip()
                                if col.isdigit():
                                    color_columns.append(int(col))
                                elif col.isalpha():
                                    color_columns.append(col.upper())
                                else:
                                    print(f"警告: 忽略无效的列标识 '{col}'")
                        else:
                            print("⚠️ 未指定列，将使用默认列")
                            color_columns = None  # 将使用默认列
                    elif color_mode == 'row':
                        # 新增：行填充时输入列
                        user_input_color = input("请输入要填充颜色的列（例如: B,C,D）: ")
                        row_color_columns = []
                        if user_input_color.strip():
                            for col in user_input_color.split(','):
                                col = col.strip()
                                if col.isdigit():
                                    row_color_columns.append(int(col))
                                elif col.isalpha():
                                    row_color_columns.append(col.upper())
                                else:
                                    print(f"警告: 忽略无效的列标识 '{col}'")
                        else:
                            print("⚠️ 未指定列，将使用默认列")
                            row_color_columns = None  # 将使用默认列
                    break
                else:
                    print("⚠️ 输入无效，请输入 'row'、'column' 或直接回车")
        # mode为3不填写颜色
        if mode == '3':
            fixed_height = 90
            chunk_size = 15
            color_mode = None
            color_columns = None
            row_color_columns = None

        # 执行拆分 (修改参数传递)
        result_path = split_excel_with_format(
            input_file,
            output_file,
            chunk_size=chunk_size,
            header_rows=header_rows,
            fixed_row_height=fixed_height,
            color_mode=color_mode,
            color_columns=color_columns,
            row_color_columns=row_color_columns  # 新增：传递行填充列参数
        )

        # 计算并显示结果信息
        wb = load_workbook(input_file)
        sheet = wb.active
        # 修改后的实际数据行计算
        total_data_rows = 0
        for row in range(3 + 1, sheet.max_row + 1):  # header_rows=3
            cell_value = sheet[row][0].value  # 第一列单元格
            if not isinstance(cell_value, (int, float)):
                break
            total_data_rows += 1
        sheet_count = math.ceil(total_data_rows / chunk_size) + 1  # 包含全量数据Sheet

        print("\n" + "=" * 50)
        print(f"✅ 文件已保存: {os.path.abspath(result_path)}")
        print(f"📊 原始数据行数: {total_data_rows} (不含表头)")
        print(f"🔢 分块大小: {chunk_size} 行/Sheet")
        print(f"📑 分割后包含 {sheet_count} 个Sheet页 (含全量数据Sheet)")
        print(f"🔀 表头合并单元格规则已完整保留")
        if fixed_height is not None:
            print(f"📏 所有行统一行高: {fixed_height} 磅")
        if color_columns:
            print(f"🎨 已为以下列填充颜色: {', '.join(str(col) for col in color_columns)}")
        print("=" * 50)
        # 截图
        os.makedirs(f'{output_dir}/images', exist_ok=True)
        capture_excel_sheets_screenshots(result_path, f'{output_dir}/images',start_from=2,header_rows=header_rows)

    except ValueError:
        print("❌ 错误：请输入有效的数字行高值（例如15、20、25等）")
    except Exception as e:
        print(f"❌ 处理失败: {str(e)}")


if __name__ == "__main__":
    input_file = "../spiltExcel/input/千股千评倒数200.xlsx"
    dateStamp = datetime.now().strftime("%Y%m%d")
    # 输出目录
    output_dir = f"../spiltExcel/output/{dateStamp}/other"
    # 新增模式选择
    mode = input("请选择模式 (1-默认配置 / 2-自定义配置 / 3-不填写颜色): ").strip()
    split_excel_inputFile(input_file,output_dir,mode,header_rows=3)
